package qc.module.platform.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.ResourceStatusFlagEnum;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.module.platform.dto.apiFilter.ApiFilterDto;
import qc.module.platform.dto.apiFilter.ApiFilterQueryConditionDto;
import qc.module.platform.entity.QcApiFilters;
import qc.module.platform.mapper.ApiFilterMapper;
import qc.module.platform.repository.QcApiFilterRepository;

import java.util.List;
import java.util.Objects;
import java.util.UUID;

/**
 * 接口日志过滤规则Service
 *
 * @author QuCheng Tech
 * @create 2023/11/03
 */
@Service
public class ApiFilterService {
    private QcApiFilterRepository repository;
    private UserService userService;

    @Autowired
    public void setRepository(QcApiFilterRepository repository) {
        this.repository = repository;
    }

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    /**
     * 查询接口日志过滤规则记录
     *
     * @param conditionDto 查询条件dto
     * @return 接口日志过滤规则记录集合
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public List<ApiFilterDto> query(ApiFilterQueryConditionDto conditionDto) {
        // 1.构造查询条件
        LambdaQueryWrapper<QcApiFilters> wrapper = new LambdaQueryWrapper<>();
        if (conditionDto != null) {
            if (StringUtils.isNotBlank(conditionDto.getFlag()))
                wrapper.eq(QcApiFilters::getFlag, Integer.parseInt(conditionDto.getFlag()));

            if (StringUtils.isNotBlank(conditionDto.getKeywords()))
                wrapper.and(q -> q.like(QcApiFilters::getUrl, conditionDto.getKeywords()));
        }

        // 2.排序：规则更新时间降序，id降序
        wrapper.orderByDesc(QcApiFilters::getUpdateTm, QcApiFilters::getId);

        // 3. 查询数据记录
        List<QcApiFilters> enList = repository.selectList(wrapper);

        //4.如果有数据记录，enList转换为dtoList返回
        if (enList.size() > 0x0)
            return ApiFilterMapper.MAPPER.toDtoList(enList);
        return null;
    }

    /**
     * 获取指定接口日志过滤规则记录
     *
     * @param id 规则ID
     * @return 指定接口日志过滤规则记录
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public ApiFilterDto get(String id) {
        // 1.根据id获取指定数据对象
        QcApiFilters en = repository.selectById(id);

        // 2.判断对象是否存在，存在则en转换为dto返回
        if (Objects.nonNull(en)) {
            return ApiFilterMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 新增接口日志过滤规则记录
     *
     * @param dto 新增内容dto
     * @return 返回null表示成功，其他表示错误或提示信息
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public String add(ApiFilterDto dto) {
        // 1.新增对象判空
        if (Objects.isNull(dto))
            return QCUnifyReturnValue.Warn("新增对象不能为空");
        if (StringUtils.isBlank(dto.getUrl()))
            return QCUnifyReturnValue.Warn("url不能为空");

        // 2.如果有用户id，判断用户id是否存在，不存在则提示
        if (dto.getUid() != null && dto.getUid() != 0x0) {
            if (!userService.hasIdExist(dto.getUid()))
                return QCUnifyReturnValue.Warn("用户不存在");
        }

        // 3. dto转为entity
        QcApiFilters en = ApiFilterMapper.MAPPER.addOrUpdateDtoToEntity(dto);

        // 4.设置id
        en.setId(UUID.randomUUID().toString());

        // 5.保存数据
        if (repository.insert(en) < 0x1)
            return QCUnifyReturnValue.Warn("保存失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改接口日志过滤规则记录
     *
     * @param dto 修改内容dto
     * @return 返回null表示成功，其他表示错误或提示信息
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public String update(ApiFilterDto dto) {
        // 1.修改对象判空
        if (Objects.isNull(dto))
            return QCUnifyReturnValue.Warn("新增对象不能为空");
        if (StringUtils.isBlank(dto.getUrl()))
            return QCUnifyReturnValue.Warn("url不能为空");

        // 2.判断修改的数据记录是否存在，不存在则提示
        if (!hasIdExist(dto.getId()))
            return QCUnifyReturnValue.Warn("修改的规则不存在");

        // 3.如果有用户id，判断用户id是否存在，不存在则提示
        if (dto.getUid() != null && dto.getUid() != 0x0) {
            if (!userService.hasIdExist(dto.getUid()))
                return QCUnifyReturnValue.Warn("用户不存在");
        }

        // 4.dto转为entity
        QcApiFilters en = ApiFilterMapper.MAPPER.addOrUpdateDtoToEntity(dto);

        // 6.更新数据
        if (repository.updateById(en) < 0x1)
            return QCUnifyReturnValue.Warn("修改失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除指定接口日志过滤规则记录
     * 物理删除
     *
     * @param id 规则ID
     * @return 返回null表示成功，其他表示错误或提示信息
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public String delete(String id) {
        // 1.判断删除的数据记录是否存在，不存在则提示
        QcApiFilters en = repository.selectById(id);
        if (Objects.isNull(en))
            return QCUnifyReturnValue.Warn("接口日志过滤规则不存在");

        // 2.删除记录
        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 启用接口日志过滤规则记录
     *
     * @param id 规则ID
     * @return 返回null表示成功，其他表示错误或提示信息
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public String enable(String id) {
        // 1.判断启用的数据记录是否存在
        QcApiFilters en = repository.selectById(id);
        if (Objects.isNull(en))
            return QCUnifyReturnValue.Warn("接口日志过滤规则不存在");

        // 2.构造更新记录条件
        LambdaUpdateWrapper<QcApiFilters> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcApiFilters::getId, id).set(QcApiFilters::getFlag, ResourceStatusFlagEnum.NORMAL);

        // 3.更新记录
        repository.update(null, wrapper);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 禁用接口日志过滤规则记录
     *
     * @param id 规则ID
     * @return 返回null表示成功，其他表示错误或提示信息
     * @author QcCheng Tech
     * @since 2023/11/03
     */
    public String disable(String id) {
        // 1.判断禁用的数据记录是否存在
        QcApiFilters en = repository.selectById(id);
        if (Objects.isNull(en))
            return QCUnifyReturnValue.Warn("接口日志过滤规则不存在");

        // 2.构造更新记录条件
        LambdaUpdateWrapper<QcApiFilters> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcApiFilters::getId, id).set(QcApiFilters::getFlag, ResourceStatusFlagEnum.DISABLE);

        // 3.更新记录
        repository.update(null, wrapper);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 判断指定记录id是否存在
     *
     * @param id: 需要查询的规则ID
     * @return boolean 存在返回true,不存在返回false
     * @author QcCheng Tech
     * @date 2023/11/6
     */
    public boolean hasIdExist(String id) {
        LambdaQueryWrapper<QcApiFilters> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(QcApiFilters::getId);
        wrapper.eq(QcApiFilters::getId, id);

        QcApiFilters en = repository.selectOne(wrapper);
        if (en != null)
            return true;

        return false;
    }

    /**
     * 生成记录ID，获取数据库表中的最大记录ID+1
     *
     * @return 生成记录ID
     * @author QuCheng Tech
     * @since 2023/11/03
     */
    //Integer generateId() {
    //    Integer maxRecordId = getMaxId();
    //    return maxRecordId + 1;
    //}

    /**
     * 获取数据库表中的最大ID值，没有记录时返回0
     *
     * @return 返回数据库表中的最大ID值
     * @author QuCheng Tech
     * @since 2023/11/03
     */
    //Integer getMaxId() {
    //    LambdaQueryWrapper<QcApiFilters> wrapper = new LambdaQueryWrapper<>();
    //    wrapper.select(QcApiFilters::getId);
    //    wrapper.orderByDesc(QcApiFilters::getId);
    //    QcApiFilters qcApiFilters = repository.selectOne(wrapper);
    //    if (qcApiFilters != null)
    //        return qcApiFilters.getId();
    //    return 0x0;
    //}
}
